import bdb

from flask import Response, jsonify, Flask, request, Blueprint,url_for
from configs import *
from modules.Tables import *
from sqlalchemy import func



# 创建蓝图，对应的register目录（激活操作视图）
model_template = Blueprint('model_template', __name__)


# 算法类型模板大类表数据展示（算法模板大类管理）
@model_template.route('/model_type_template_show', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_type_template_show():
    """
    算法模板信息展示（支持分页）
    page（str）： 当前页码
    per_page（str）： 每页显示条目数量
    """

    # 获取分页参数
    page = request.args.get('page', default=1, type=int)  # 当前页码
    per_page = request.args.get('per_page', default=15, type=int)  # 每页显示条目数量

    # 查询主区域点并进行分页
    pagination = db.session.query(Model_template_config_type).filter(~Model_template_config_type.id.in_([2, 3, 5])).paginate(page=page, per_page=per_page, error_out=False)

    # 获取分页后的数据
    data_list = [
        {
            'id': item.id,
            'model_type_name': item.model_type_name,
            'model_type_content': item.model_type_content,
            'created_at': item.created_at,
            'updated_at': item.updated_at,

        }
        for item in pagination.items
    ]

    # 构造返回结果，包括分页信息
    response = {
        'code': 200,
        'data': data_list,
        'pagination': {
            'current_page': pagination.page,
            'total_pages': pagination.pages,
            'total_items': pagination.total,
            'per_page': pagination.per_page
        }
    }

    return jsonify({'code':200,'data':response})



# 算法类型模板表数据展示（算法模板管理）
@model_template.route('/model_template_show', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_template_show():
    """
    算法模板信息展示（支持分页）
    page（str）： 当前页码
    per_page（str）： 每页显示条目数量
    """

    # 获取分页参数
    page = request.args.get('page', default=1, type=int)  # 当前页码
    per_page = request.args.get('per_page', default=15, type=int)  # 每页显示条目数量
    model_type = request.args.get('model_type', type=int)  # 算法类型
    model_template_config_type_id = request.args.get('model_template_config_type_id', type=int)  # 大类id


    # 定义筛选列表
    filters = []
    # 当筛选条件存在用户时添加到列表
    if model_type:
        filters.append(Model_template_config.model_type == model_type)
    if model_template_config_type_id:
        filters.append(Model_template_config.model_template_config_type_id == model_template_config_type_id)

    # 构建查询条件
    query = and_(*filters) if filters else True  # 如果 filters 为空，默认条件为 True

    # 查询主区域点并进行分页
    pagination = db.session.query(Model_template_config).filter(query,~Model_template_config.model_template_config_type_id.in_([2, 3, 5])).paginate(page=page, per_page=per_page, error_out=False)

    # 获取分页后的数据
    data_list = [
        {
            'id': item.id,
            'model_name': item.model_name,
            'model_type': item.model_type,
            # 'conf_area': item.conf_area,
            'model_conf_list': item.model_conf_list,
            'image': item.image,
            'content': item.content,
            # 'equipment_id': item.equipment_id,
            # 'image':('/static/' + str(os.path.basename(r.get_string('em_{}'.format(item.equipment_id))))
            # if item.equipment_id and r.get_string('em_{}'.format(item.equipment_id))
            # else ''),
            'created_at': item.created_at,
            'updated_at': item.updated_at,
            'model_template_config_type_id': item.model_template_config_type_id,

        }
        for item in pagination.items
    ]

    # 构造返回结果，包括分页信息
    response = {
        'code': 200,
        'data': data_list,
        'pagination': {
            'current_page': pagination.page,
            'total_pages': pagination.pages,
            'total_items': pagination.total,
            'per_page': pagination.per_page
        }
    }

    return jsonify({'code':200,'data':response})


# 大类下方小类展示（算法模板管理）
@model_template.route('/model_template_small_show', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_template_small_show():
    """
    算法模板信息展示（支持分页）
    page（str）： 当前页码
    per_page（str）： 每页显示条目数量
    """

    # 获取分页参数
    page = request.args.get('page', default=1, type=int)  # 当前页码
    per_page = request.args.get('per_page', default=15, type=int)  # 每页显示条目数量
    model_template_type_id = request.args.get('model_template_type_id', type=int)  # 模板大类id


    # 定义筛选列表
    filters = []
    # 当筛选条件存在时添加到列表
    if model_template_type_id:
        filters.append(Model_template_small.model_template_config_type_id == model_template_type_id)

    # 构建查询条件
    query = and_(*filters) if filters else True  # 如果 filters 为空，默认条件为 True

    # 查询主区域点并进行分页
    pagination = (
        db.session.query(Model_template_small.id,
                         Model_template_small.template_small_name,
                         Model_template_small.template_small_number,
                         Model_template_small.template_small_gauss,
                         Model_template_small.template_small_threshold,
                         Model_template_small.template_small_iou,
                         Model_template_small.template_small_start,
                         Model_template_small.template_small_end,
                         Model_template_small.template_small_upload,
                         Model_template_small.model_template_config_type_id,
                         Model_template_small.list_data,
                         Model_template_config_type.model_type_name,
                         Model_template_small.created_at,
                         Model_template_small.updated_at,
                         )
            .join(
            Model_template_config_type,
            Model_template_config_type.id == Model_template_small.model_template_config_type_id
        )
            .filter(query,~Model_template_config_type.id.in_([2, 3, 5]))
            .paginate(page=page, per_page=per_page, error_out=False)
    )




    # 获取分页后的数据
    data_list = [
        {
            'id': item.id,
            'template_small_name': item.template_small_name,
            'list_data': eval(item.list_data) if item.list_data else [{}],  # 安全处理 list_data,
            'template_small_number': item.template_small_number,
            'template_small_gauss': item.template_small_gauss,
            'template_small_threshold': item.template_small_threshold,
            'template_small_iou': item.template_small_iou,
            'template_small_start': item.template_small_start,
            'template_small_end': item.template_small_end,
            'template_small_upload': item.template_small_upload,
            'model_template_config_type_id': item.model_template_config_type_id,
            'model_template_config_type_name':item.model_type_name,
            'created_at': item.created_at,
            'updated_at': item.updated_at,

        }
        for item in pagination.items
    ]



    # 构造返回结果，包括分页信息
    response = {
        'code': 200,
        'data': data_list,
        'pagination': {
            'current_page': pagination.page,
            'total_pages': pagination.pages,
            'total_items': pagination.total,
            'per_page': pagination.per_page
        }
    }

    return jsonify({'code':200,'data':response})


@model_template.route('/model_template_detail', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_template_detail():
    """
    算法类型模板表单详情接口
    参数:
        id (str): 模板ID
    返回:
        JSON响应: 模板详情数据或错误消息
    """

    # 获取模板id
    template_id = request.args.get('id')

    # 参数校验
    if not template_id:
        return jsonify({'code': 400, 'msg': '模板ID未填写'})

    try:
        # 查询模板详情
        template_detail = db.session.query(Model_template_config).filter_by(id=template_id).first()

        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})

        # # 从 Redis 获取图片路径
        # r = Redis(Redis_ip, Redis_port, 'list')
        # redis_key = f'em_{template_detail.equipment_id}' if template_detail.equipment_id else None
        # redis_value = r.get_string(redis_key) if redis_key else None

        # 构造响应数据
        data = {
            'id': template_detail.id,
            'model_name': template_detail.model_name,
            'model_type': template_detail.model_type,
            # 'conf_area': template_detail.conf_area,
            'model_conf_list': template_detail.model_conf_list,
            'image': template_detail.image,
            'content': template_detail.content,
            # 'equipment_id': template_detail.equipment_id,
            # 'image': f'/static/{os.path.basename(redis_value)}' if redis_value else '',
            'created_at': template_detail.created_at,
            'updated_at': template_detail.updated_at,
            'model_template_config_type_id': template_detail.model_template_config_type_id,
        }

        return jsonify({'code': 200, 'data': data})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})

# 大类下方小类详情（算法模板管理）
@model_template.route('/model_small_detail', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_small_detail():
    """
    算法类型模板表单详情接口
    参数:
        id (str): 模板ID
    返回:
        JSON响应: 模板详情数据或错误消息
    """

    # 获取模板id
    id = request.args.get('id')

    # 参数校验
    if not id:
        return jsonify({'code': 400, 'msg': '模板ID未填写'})

    try:
        # 查询模板详情
        template_detail = db.session.query(Model_template_small).filter_by(id=id).first()

        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})

        # 查询模板大类类型名称
        template_type_name = db.session.query(Model_template_config_type).filter(Model_template_config_type.id==template_detail.model_template_config_type_id).first()

        # 构造响应数据
        data = {
            'id': template_detail.id,
            'template_small_name': template_detail.template_small_name,
            'list_data': eval(template_detail.list_data),
            'template_small_number': template_detail.template_small_number,
            'template_small_gauss': template_detail.template_small_gauss,
            'template_small_threshold': template_detail.template_small_threshold,
            'template_small_iou': template_detail.template_small_iou,
            'template_small_start': template_detail.template_small_start,
            'template_small_end': template_detail.template_small_end,
            'template_small_upload': template_detail.template_small_upload,
            'model_template_config_type_id': template_detail.model_template_config_type_id,
            'model_template_config_type_name':template_type_name.model_type_name,
            'created_at': template_detail.created_at,
            'updated_at': template_detail.updated_at,
        }

        return jsonify({'code': 200, 'data': data})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})


# 算法类型模板大类表数据详情（算法模板大类管理）
@model_template.route('/model_type_template_detail', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def model_type_template_detail():
    """
    算法类型模板表单详情接口
    参数:
        id (str): 模板ID
    返回:
        JSON响应: 模板详情数据或错误消息
    """

    # 获取模板id
    id = request.args.get('id')

    # 参数校验
    if not id:
        return jsonify({'code': 400, 'msg': '模板ID未填写'})

    try:
        # 查询模板详情
        template_detail = db.session.query(Model_template_config_type).filter(Model_template_config_type.id==id).first()

        if not template_detail:
            return jsonify({'code': 404, 'msg': '大类模板不存在'})

        # 构造响应数据
        data = {
            'id': template_detail.id,
            'model_type_name': template_detail.model_type_name,
            'model_type_content': template_detail.model_type_content,
            'created_at': template_detail.created_at,
            'updated_at': template_detail.updated_at,
        }

        return jsonify({'code': 200, 'data': data})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})


# 算法类型模板表数据修改（算法模板管理）
@model_template.route('/model_template_update', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_update():
    """
    算法类型模板表数据修改接口
    参数:
        id (str): 模板ID
        equipment_id (str): 设备ID
        conf_area (str): 区域数据
        model_conf_list (str): 基础配置参数
        model_type (str): 算法类型 1串 2单
    返回:
        JSON响应: 修改成功或错误消息
    """

    try:
        # 获取请求参数
        template_id = strip_whitespace(request.form.get('id',None))
        # equipment_id = strip_whitespace(request.form.get('equipment_id',None))
        # conf_area = strip_whitespace(request.form.get('conf_area',None))
        model_conf_list = strip_whitespace(request.form.get('model_conf_list',None))
        model_name = strip_whitespace(request.form.get('model_name',None))
        model_template_config_type_id = strip_whitespace(request.form.get('model_template_config_type_id',None))

        # 参数校验
        if not template_id:
            return jsonify({'code': 400, 'msg': '模板ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_config).filter_by(id=template_id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})

        # 更新数据（仅更新不为 None 的字段）
        # if equipment_id is not None:
        #     template_detail.equipment_id = equipment_id
        # if conf_area is not None:
        #     template_detail.conf_area = conf_area
        if model_conf_list is not None:
            template_detail.model_conf_list = model_conf_list
        if model_name is not None:
            template_detail.model_name = model_name
        if model_template_config_type_id is not None:
            template_detail.model_template_config_type_id = model_template_config_type_id

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '修改成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})


# 大类下方小类修改（算法模板管理）
@model_template.route('/model_template_small_update', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_small_update():
    try:

        def time_zh(data):

            try:
                # 检查 data 是否为字符串类型
                if not isinstance(data, str):
                    return data  # 如果不是字符串，直接返回原值

                # 尝试提取并解析时间
                parsed_time = datetime.strptime(data.split("GMT")[0].strip(), "%a %b %d %Y %H:%M:%S")

                # 格式化为时分秒
                formatted_time = parsed_time.strftime("%H:%M:%S")
                return formatted_time
            except (ValueError, AttributeError):
                # 如果解析失败或格式错误，返回原值
                return data

        # 获取请求参数
        id = strip_whitespace(request.form.get('id',None))
        list_data = strip_whitespace(request.form.get('list_data','[{}]'))
        model_template_config_type_id = strip_whitespace(request.form.get('model_template_config_type_id',None))
        template_small_name = strip_whitespace(request.form.get('template_small_name',''))
        template_small_number = strip_whitespace(request.form.get('template_small_number',''))
        template_small_gauss = strip_whitespace(request.form.get('template_small_gauss',''))
        template_small_threshold = strip_whitespace(request.form.get('template_small_threshold',''))
        template_small_iou = strip_whitespace(request.form.get('template_small_iou',''))
        template_small_start = time_zh(strip_whitespace(request.form.get('template_small_start','')))
        template_small_end = time_zh(strip_whitespace(request.form.get('template_small_end','')))
        template_small_upload = time_zh(strip_whitespace(request.form.get('template_small_upload','')))

        # 参数校验
        if not id:
            return jsonify({'code': 400, 'msg': '模板小类ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_small).filter_by(id=id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})

        if model_template_config_type_id is not None:
            template_detail.model_template_config_type_id = model_template_config_type_id
        if template_small_name is not None or template_small_name == 'null':
            template_detail.template_small_name = template_small_name or ''
        if template_small_number is not None or template_small_number == 'null':
            template_detail.template_small_number = template_small_number or ''
        if template_small_threshold is not None or template_small_threshold == 'null':
            template_detail.template_small_threshold = template_small_threshold or ''
        if template_small_gauss is not None or template_small_gauss == 'null':
            template_detail.template_small_gauss = template_small_gauss or ''
        if template_small_start is not None or template_small_start == 'null':
            template_detail.template_small_start = template_small_start or ''
        if template_small_end is not None or template_small_end == 'null':
            template_detail.template_small_end = template_small_end or ''
        if template_small_upload is not None or template_small_upload == 'null':
            template_detail.template_small_upload = template_small_upload or ''
        if template_small_iou is not None or template_small_iou == 'null':
            template_detail.template_small_iou = template_small_iou or ''
        if list_data is not None:
            template_detail.list_data=list_data or '[{}]'

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '修改成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})


# 算法类型模板大类表数据修改（算法模板大类管理）
@model_template.route('/model_type_template_update', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_type_template_update():
    try:

        # 获取请求参数
        id = strip_whitespace(request.form.get('id',None))
        model_type_name = strip_whitespace(request.form.get('model_type_name',None))
        model_type_content = strip_whitespace(request.form.get('model_type_content',''))

        # 参数校验
        if not id:
            return jsonify({'code': 400, 'msg': '模板大类ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_config_type).filter(Model_template_config_type.id==id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})

        if model_type_name is not None:
            template_detail.model_type_name = model_type_name
        if model_type_content is not None :
            template_detail.model_type_content = model_type_content


        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '修改成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})



# 大类下方小类新增（算法模板管理）
@model_template.route('/model_template_small_add', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_small_add():
    """
    算法类型模板表数据修改接口
    参数:
        model_template_config_type_id (str): 算法模板大类id
        list_data (str): 模板数据
        template_small_name (str): 模板小类名称
    返回:
        JSON响应: 修改成功或错误消息
    """

    # 获取请求参数
    model_template_config_type_id = strip_whitespace(request.form.get('model_template_config_type_id', None))
    list_data = strip_whitespace(request.form.get('list_data', '[{}]'))
    template_small_name = strip_whitespace(request.form.get('template_small_name', None))

    print(type(list_data),'list_data')
    # 参数构建判断是否为空
    params = [model_template_config_type_id,list_data,template_small_name]

    if not all(params):
        return jsonify({'code': 400, 'msg': '模板数据有未填写项'})

    if db.session.query(Model_template_small).filter(Model_template_small.template_small_name==template_small_name).first():
        return jsonify({'code': 400, 'msg':'该算法模板已经存在！'})

    # 创建新的记录
    new_template = Model_template_small(template_small_name=template_small_name,
                                        model_template_config_type_id=model_template_config_type_id,
                         list_data=list_data)
    try:
        # 将新数据添加到数据库会话
        db.session.add(new_template)
        db.session.commit()  # 提交

        return jsonify({'code': 200, 'msg': '算法模板添加成功！'})

    except Exception as e:

        # 发生异常时回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'msg': f'算法类型模板添加失败: {str(e)}'})



# 算法类型模板小类数据新增（算法模板管理）
@model_template.route('/model_template_add', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_add():
    """
    算法类型模板表数据修改接口
    参数:
        model_conf_list (str): 基础配置参数
        model_name (str): 算法类型名称
        model_type (str): 算法类型 1 串 2 单
        equipment_id (str): 设备ID
        conf_area (str): 区域数据
    返回:
        JSON响应: 修改成功或错误消息
    """

    # 获取请求参数
    # equipment_id = strip_whitespace(request.form.get('equipment_id', None))
    # conf_area = strip_whitespace(request.form.get('conf_area', None))
    model_conf_list = strip_whitespace(request.form.get('model_conf_list', None))
    model_name = strip_whitespace(request.form.get('model_name', None))
    model_template_config_type_id = strip_whitespace(request.form.get('model_template_config_type_id', None))

    # 参数构建判断是否为空
    params = [model_name,model_template_config_type_id]

    if not all(params):
        return jsonify({'code': 400, 'msg': '模板数据有未填写项'})

    if db.session.query(Model_template_config).filter(Model_template_config.model_name==model_name).first():
        return jsonify({'code': 400, 'msg':'该算法类型已经存在！'})

    # 创建新的记录
    new_template = Model_template_config(model_name=model_name,
                         model_template_config_type_id=model_template_config_type_id)

    try:
        # 将新角色添加到数据库会话
        db.session.add(new_template)
        db.session.commit()  # 提交以获取新用户的ID

        return jsonify({'code': 200, 'msg': '算法类型模板添加成功！'})

    except Exception as e:

        # 发生异常时回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'msg': f'算法类型模板添加失败: {str(e)}'})



# 算法类型模板大类表数据新增（算法模板大类管理）
@model_template.route('/model_type_template_add', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_type_template_add():
    """
    算法类型模板表数据修改接口
    参数:
        model_type_content (str): 算法模板大类描述
        model_type_name (str): 算法模板大类名称
    返回:
        JSON响应: 修改成功或错误消息
    """

    # 获取请求参数
    model_type_content = strip_whitespace(request.form.get('model_type_content',None))
    model_type_name = strip_whitespace(request.form.get('model_type_name', None))

    # 参数构建判断是否为空
    params = [model_type_content,model_type_name]

    if not all(params):
        return jsonify({'code': 400, 'msg': '模板数据有未填写项'})

    if db.session.query(Model_template_config_type).filter(Model_template_config_type.model_type_name==model_type_name).first():
        return jsonify({'code': 400, 'msg':'该算法模板已经存在！'})

    # 创建新的记录
    new_template = Model_template_config_type(model_type_content=model_type_content,
                                        model_type_name=model_type_name)
    try:
        # 将新数据添加到数据库会话
        db.session.add(new_template)
        db.session.commit()  # 提交

        return jsonify({'code': 200, 'msg': '算法大类模板添加成功！'})

    except Exception as e:

        # 发生异常时回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'msg': f'算法类型模板添加失败: {str(e)}'})



# 算法类型模板表数据删除（算法模板管理）
@model_template.route('/model_template_delete', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_delete():
    try:
        # 获取请求参数
        template_id = strip_whitespace(request.form.get('id',None))
        # 参数校验
        if not template_id:
            return jsonify({'code': 400, 'msg': '要删除ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_config).filter_by(id=template_id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '模板不存在'})
        else:
            db.session.query(Model_template_config).filter(Model_template_config.id==template_id).delete()

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '删除成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})




# 算法类型模板表数据删除（算法模板管理）
@model_template.route('/model_template_small_delete', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_template_small_delete():
    try:
        # 获取请求参数
        template_id = strip_whitespace(request.form.get('id',None))
        # 参数校验
        if not template_id:
            return jsonify({'code': 400, 'msg': '要删除ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_small).filter(Model_template_small.id==template_id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '小类模板不存在'})
        else:
            db.session.query(Model_template_small).filter(Model_template_small.id==template_id).delete()

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '删除成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})


# 算法类型模板大类表数据删除（算法模板大类管理）
@model_template.route('/model_type_template_delete', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def model_type_template_delete():
    try:
        # 获取请求参数
        template_id = strip_whitespace(request.form.get('id',None))
        # 参数校验
        if not template_id:
            return jsonify({'code': 400, 'msg': '要删除ID未填写'})

        # 查询模板数据
        template_detail = db.session.query(Model_template_config_type).filter(Model_template_config_type.id==template_id).first()
        if not template_detail:
            return jsonify({'code': 404, 'msg': '小类模板不存在'})
        else:
            db.session.query(Model_template_config_type).filter(Model_template_config_type.id==template_id).delete()

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '删除成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})





